1. Field of the Invention
The present invention relates to the field of computer stored data base systems and, more particularly, to a new and improved method of software register allocation between the calling program and the called subroutine in a command analysis table.
2. Description of the Prior Art
Stored program control, digital telephone switching systems are modern replacements for the electromechanical telecommunication systems used in years past. These distributed microprocessor controlled systems include an administrative processor, telephony processors, local and remote switching processors, and remote line processors. The data base for such systems is distributed in memories in many of the processor complexes of the telephone switch. Administration of such large and complex data bases requires a system that is table-driven to the extent that virtually all the protected data concerning administration of the data base and analysis of data base commands is in tables. This allows for an efficient fully engineerable on-line data base that provides access to the data to easily accommodate changes in service or features.
The system data base is modified by Recent Change (RC) commands, which are input to the system via a terminal or magnetic media. The RC commands act upon and/or modify the resident data base according to program directives defined by Command Analysis Tables (CAT). Commands entered into the system are processed according to data residing in the CAT program and the existing command validation routines in the central data base. The resulting office dependent data base changes are applied back to the central data base and to the peripheral processors.
Therefore, CAT program code, is table driven software. Data, that is internal to a CAT code program for intermediate calculations and manipulations, is stored in special software registers residing in system memory. The main CAT programs, as well as its subroutines, share these registers for data manipulation, data storage and data passing.
In the past RC commands were simple in nature, with the program code being fairly straight forward with little sophistication in its coding techniques. Handling of the aforementioned software registers was not perceived to be a problem when designing the CAT program code and its constructs. However, with the introduction of complicated telephony features, the data base manipulation requirements became more difficult. This led to larger CAT code programs requiring more complicated coding techniques. In the CAT code program language, there is no such structure as a local variable. The defined software registers are the variables. The designer or programmer ultimately determines register usage. Problems arise with register usage when a main program using a particular register calls a subroutine which uses the same register locally.
All data used by subroutines in the CAT operating code are passed through registers. A set number of registers are allocated to Input/Output (I/O), and general use. In this environment, every designer or programmer having a routine that uses any register, must choose these registers cautiously. Since the registers are a shared resource, a designer must be aware of the registers used by the main program and any subroutines. This ultimately results in CAT code routines that are tightly coupled. Tightly coupled routines carry the risk of having a modification to a subroutine adversely affect other existing routines within the program.
This situation can create a maintenance environment that is error prone. To support new features within the telephony system, new programs are introduced, and old programs modified to acquire new functions. Further, to fix errors in existing routines requires additional use of registers. Still further, each piece of software is maintained by a person other than its designer or programmer. All of these factors aggravate the problems in tracking the usable registers across the many programs and routines in the CAT program, which inevitably leads to register corruption.
Therefore, it is advantageous to provide an arrangement that allows new routines to be written in such a way as to let parameter passing to be largely transparent, with no register tracking. Such an arrangement, would not require the need to track register usage for possible corruption in the calling programs.
Accordingly, it is an object of the present invention, to provide a method that provides for local variables in each subroutine, to prevent corruption of global variables. It is a further object of the present invention, to provide a method that reduces the effort normally required when coding subroutines, by shielding the designer or programmer from register usage and assignment. It is still a further object of the present invention, to provide a method that saves development effort by promoting subroutine reuse between command programs, in order to reduce the number of errors in coding new routines.